package com.heny.demo.model.enu;

import com.heny.demo.common.CommonErrorCode;
import com.heny.demo.common.CommonException;

import java.util.List;
import java.util.function.Function;

/**
 * @author litao.cc
 * @version AggregationTypeEnum.java v0.1 t2025/5/6 21:10
 * @date 2025/5/6 21:10
 * @description AggregationTypeEnum
 */
public enum AggregationTypeEnum {

    /**
     * 计算平均值（AVERAGE）：
     * 对传入的数据列表求和后除以元素个数。
     */
    AVERAGE(data -> {
        if (data == null || data.isEmpty()) {
            return null;
        }
        double sum = 0;
        for (Double d : data) {
            sum += d;
        }
        return sum / data.size();
    }),

    /**
     * 取最大值（MAXIMUM）：
     * 返回数据列表中的最大值。
     */
    MAXIMUM(data -> {
        if (data == null || data.isEmpty()) {
            return null;
        }
        double max = Double.MIN_VALUE;
        for (Double d : data) {
            if (d != null && d > max) {
                max = d;
            }
        }
        return max;
    }),

    /**
     * 取最小值（MINIMUM）：
     * 返回数据列表中的最小值。
     */
    MINIMUM(data -> {
        if (data == null || data.isEmpty()) {
            return null;
        }
        double min = Double.MAX_VALUE;
        for (Double d : data) {
            if (d != null && d < min) {
                min = d;
            }
        }
        return min;
    }),

    /**
     * 求首尾差值（DIFFERENCE）：
     * 返回列表中第一个元素与最后一个元素的绝对差。
     * 如果数据不足两个，则返回 null。
     */
    DIFFERENCE(data -> {
        if (data == null || data.size() < 2) {
            return null;
        }
        return Math.abs(data.get(0) - data.get(data.size() - 1));
    }),

    /**
     * 求总和（SUM）：
     * 将数据列表中的所有数值相加。
     */
    SUM(data -> {
        if (data == null || data.isEmpty()) {
            return null;
        }
        double sum = 0;
        for (Double d : data) {
            if (d != null) {
                sum += d;
            }
        }
        return sum;
    }),

    /**
     * 统计数量（COUNT）：
     * 返回数据列表中元素的个数。
     */
    COUNT(data -> {
        if (data == null) {
            return null;
        }
        return (double) data.size();
    });

    private final Function<List<Double>, Double> computeFunction;

    AggregationTypeEnum(Function<List<Double>, Double> computeFunction) {
        this.computeFunction = computeFunction;
    }

    public Double apply(List<Double> data) {
        return computeFunction.apply(data);
    }

    /**
     * 根据传入的聚合类型名称执行计算
     *
     * @param type 类型名称，如 "MAXIMUM"
     * @param data 输入数据列表
     * @return 计算结果
     * @throws IllegalArgumentException 如果类型不存在
     */
    public static Double calculate(String type, List<Double> data) {
        try {
            AggregationTypeEnum aggregationType = AggregationTypeEnum.valueOf(type.toUpperCase());
            return aggregationType.apply(data);
        } catch (IllegalArgumentException e) {
            throw new CommonException(CommonErrorCode.PARAM_VALIDATION_FAILED,"不支持的聚合类型: " + type);
        }
    }
}